package com.ics.atable.chat.service;

import org.springframework.stereotype.Service;

import java.text.Normalizer;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 指标别名替换服务
 *
 * 职责：
 * - 接收 input SQL 与 replace 规则集（Map 或 List[{from,to}]）
 * - 按规则集进行批量替换（最长优先、全半角归一）
 * - 返回替换后的 SQL 文本
 *
 * 注意：当前实现为简单文本替换；如需“仅替换列值而非列名/关键字”，可扩展为：
 * 1) SQL 分段（跳过注释/字符串字面量）或
 * 2) 整词/边界匹配正则 或
 * 3) 轻量 SQL 解析
 */
@Service
public class MetricAliasService {

    /**
     * 将替换规则集合应用于原始 SQL。
     *
     * @param originalSql  原始 SQL
     * @param replaceRules 规则集合（Map 或 List[{from,to}]）
     * @return 替换后的 SQL
     */
    public String applyReplacements(String originalSql, Object replaceRules) {
        if (originalSql == null) {
            return "";
        }
        if (replaceRules == null) {
            return originalSql;
        }

        Map<String, String> rules = toRuleMap(replaceRules);
        if (rules.isEmpty()) {
            return originalSql;
        }

        // 归一化输入，避免原文全角/半角与规则不一致导致无法命中
        String replaced = originalSql;

        // 遍历所有规则，直接替换字段值
        for (Map.Entry<String, String> e : rules.entrySet()) {
            String fieldName = e.getKey();
            String newValue = e.getValue();
            
            // 构造要替换的完整模式（支持带引号和不带引号的情况）
            String oldPattern;
            String newPattern;
            
            // 先尝试匹配带引号的情况
            oldPattern = "(" + fieldName + "\\s*=\\s*)'([^']*)'";
            // 新值是否需要引号
            if (newValue.matches("\\d+")) {  // 如果新值是数字
                newPattern = "$1" + newValue;
            } else {
                newPattern = "$1'" + newValue + "'";
            }
            
            // 使用正则表达式进行替换
            replaced = replaced.replaceAll(oldPattern, newPattern);
            
            // 再尝试匹配不带引号的情况
            oldPattern = "(" + fieldName + "\\s*=\\s*)([^\\s]+)";
            // 新值是否需要引号
            if (newValue.matches("\\d+")) {  // 如果新值是数字
                newPattern = "$1" + newValue;
            } else {
                newPattern = "$1'" + newValue + "'";
            }
            
            // 使用正则表达式进行替换
            replaced = replaced.replaceAll(oldPattern, newPattern);
        }
        return replaced;
    }
    
    /**
     * 从SQL语句中提取指定字段的值
     * @param sql SQL语句
     * @param fieldName 字段名
     * @return 字段值，如果未找到则返回null
     */
    private String extractFieldValueFromSql(String sql, String fieldName) {
        // 匹配格式：字段名 = '值' 或 字段名= '值' 或 字段名 ='值' 或 字段名 ='值'
        Pattern pattern = Pattern.compile(fieldName + "\\s*=\\s*'([^']*)'", Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(sql);

        // 查找匹配项，返回字段值
        if (matcher.find()) {
            String value = matcher.group(1);
            return value != null && !value.trim().isEmpty() ? value : null;
        }

        // 也检查不带引号的情况
        Pattern patternNoQuotes = Pattern.compile(fieldName + "\\s*=\\s*([^\\s]+)", Pattern.CASE_INSENSITIVE);
        Matcher matcherNoQuotes = patternNoQuotes.matcher(sql);
        if (matcherNoQuotes.find()) {
            String value = matcherNoQuotes.group(1);
            return value != null && !value.trim().isEmpty() ? value : null;
        }

        return null;
    }

    /**
     * 将 Map 形式或 List 规则数组统一转换为 Map 规则表。
     */
    private Map<String, String> toRuleMap(Object replaceRules) {
        if (replaceRules instanceof Map) {
            Map<?, ?> input = (Map<?, ?>) replaceRules;
            Map<String, String> m = new HashMap<>();
            for (Map.Entry<?, ?> en : input.entrySet()) {
                if (en.getKey() == null || en.getValue() == null) continue;
                m.put(String.valueOf(en.getKey()), String.valueOf(en.getValue()));
            }
            return m;
        }
        if (replaceRules instanceof Collection) {
            Map<String, String> m = new HashMap<>();
            for (Object item : (Collection<?>) replaceRules) {
                if (item instanceof Map) {
                    Object from = ((Map<?, ?>) item).get("from");
                    Object to = ((Map<?, ?>) item).get("to");
                    if (from != null && to != null) {
                        m.put(String.valueOf(from), String.valueOf(to));
                    }
                }
            }
            return m;
        }
        return Collections.emptyMap();
    }

    /**
     * 安全替换：当前为直接替换。
     * 可扩展为整词/边界匹配（正则）或跳过字符串/注释片段。
     */
    private String safeReplace(String text, String from, String to) {
        return text.replace(from, to);
    }

    /**
     * 归一化为半角形式，降低全角/半角差异导致的未命中概率。
     */
    private String normalizeHalfWidth(String s) {
        if (s == null) return null;
        String n = Normalizer.normalize(s, Normalizer.Form.NFKC);
        return n;
    }
}


